90f3c6f3fed25335b3d64553cc7fe94854581d7b,java/java-indexing-impl/src/com/intellij/psi/impl/search/JavaFunctionalExpressionSearcher.java,JavaFunctionalExpressionSearcher,collectFunctionalExpressions,#PsiClass#Collection#SearchScope#,59

Before Change


                    ((PsiAssignmentExpression)varElementParent).getLExpression() == varElement) {
                  final PsiExpression rExpression = PsiUtil.skipParenthesizedExprDown(((PsiAssignmentExpression)varElementParent).getRExpression());
                  if (rExpression instanceof PsiFunctionalExpression) {
                    result.add((PsiFunctionalExpression)rExpression);
                  }
                }
              }

After Change



  public static boolean collectFunctionalExpressions(final PsiClass aClass,
                                                     final SearchScope searchScope,
                                                     final Processor<PsiFunctionalExpression> consumer) {
    final SearchScope classScope = ApplicationManager.getApplication().runReadAction(new Computable<SearchScope>() {
      @Override
      public SearchScope compute() {
        return aClass.getUseScope();
      }
    });
    final SearchScope useScope = searchScope.intersectWith(classScope);
    final Project project = aClass.getProject();
    final GlobalSearchScope scope = useScope instanceof GlobalSearchScope ? (GlobalSearchScope)useScope : new EverythingGlobalScope(project);
    final Collection<PsiMethod> lambdaCandidates = ApplicationManager.getApplication().runReadAction(new Computable<Collection<PsiMethod>>() {
      @Override
      public Collection<PsiMethod> compute() {
        final String functionalInterfaceName = aClass.getName();
        final GlobalSearchScope useClassScope = classScope instanceof GlobalSearchScope ? (GlobalSearchScope)classScope : scope;
        return JavaMethodParameterTypesIndex.getInstance().get(functionalInterfaceName, project, useClassScope);
      }
    });
    for (PsiMethod psiMethod : lambdaCandidates) {
      for (PsiReference ref : MethodReferencesSearch.search(psiMethod, scope, false)) {
        final PsiElement refElement = ref.getElement();
        if (refElement != null) {
          final PsiElement candidateElement = refElement.getParent();
          if (candidateElement instanceof PsiCallExpression) {
            final PsiExpressionList argumentList = ((PsiCallExpression)candidateElement).getArgumentList();
            if (argumentList != null) {
              final Boolean accepted = ApplicationManager.getApplication().runReadAction(new Computable<Boolean>() {
                @Override
                public Boolean compute() {
                  final PsiExpression[] args = argumentList.getExpressions();
                  for (PsiExpression arg : args) {
                    if (arg instanceof PsiFunctionalExpression) {
                      final PsiFunctionalExpression functionalExpression = (PsiFunctionalExpression)arg;
                      final PsiType functionalType = functionalExpression.getFunctionalInterfaceType();
                      if (PsiUtil.resolveClassInType(functionalType) == aClass) {
                        if (!consumer.process(functionalExpression)) return false;
                      }
                    }
                  }
                  return true;
                }
              });
              if (!accepted) return false;
            }
          }
        }
      }
    }

    for (PsiReference reference : ReferencesSearch.search(aClass, scope)) {
      final PsiElement element = reference.getElement();
      if (element != null) {
        final PsiElement parent = element.getParent();
        if (parent instanceof PsiTypeElement) {
          final PsiElement gParent = parent.getParent();
          if (gParent instanceof PsiVariable) {
            final PsiExpression initializer = PsiUtil.skipParenthesizedExprDown(((PsiVariable)gParent).getInitializer());
            if (initializer instanceof PsiFunctionalExpression) {
              if (!consumer.process((PsiFunctionalExpression)initializer)) return false;
            }
            for (PsiReference varRef : ReferencesSearch.search(parent, scope)) {
              final PsiElement varElement = varRef.getElement();
              if (varElement != null) {
                final PsiElement varElementParent = varElement.getParent();
                if (varElementParent instanceof PsiAssignmentExpression && 
                    ((PsiAssignmentExpression)varElementParent).getLExpression() == varElement) {
                  final PsiExpression rExpression = PsiUtil.skipParenthesizedExprDown(((PsiAssignmentExpression)varElementParent).getRExpression());
                  if (rExpression instanceof PsiFunctionalExpression) {
                    if (!consumer.process((PsiFunctionalExpression)rExpression)) return false;
                  }
                }
              }